const db=require('../db/index.js')
const bcrypt = require('bcryptjs')
const jwt = require('jsonwebtoken')
const config = require('../config')
const queryDb = (sql, params) => {
  return new Promise((resolve, reject) => {
    db.query(sql, params, (err, result) => {
      if (err) reject(err); // 出错时 reject
      else resolve(result); // 成功时 resolve 结果
    });
  });
};

const login = async (req, res) => {
  try {
    const user = req.body;
    // 1. 校验规则（与注册保持一致）
    const student_idRegex = /^\d{12}$/;
    const passwordRegex = /^[a-zA-Z0-9]{8,12}$/;

    // 2. 基础参数校验（同步逻辑，直接判断）
    if (!user.student_id || !user.password) {
      return res.send({
        status: 400,
        message: '学号或密码不能为空'
      });
    } else if (!student_idRegex.test(user.student_id)) {
      return res.send({
        status: 400,
        message: '学号应为12位数字'
      });
    } else if (!passwordRegex.test(user.password)) {
      return res.send({
        status: 400,
        message: '密码应为8到12位数字或字母'
      });
    }

    // 3. 查询数据库（异步操作，用 await 等待结果）
    const sql = `select * from users where student_id=?`;
    const result = await queryDb(sql, [user.student_id]); // 线性等待查询结果

    // 4. 验证学号是否存在
    if (result.length !== 1) {
      return res.send({
        status: 400,
        message: '该学号未注册'
      });
    }

    // 5. 验证密码（bcrypt.compareSync 是同步方法，直接调用）
    const isPasswordValid = bcrypt.compareSync(user.password, result[0].password);
    if (!isPasswordValid) {
      return res.send({
        status: 400,
        message: '密码错误'
      });
    }

    // 6. 生成 Token（清除敏感信息）
    const userData = { ...result[0], password: '' };
    const token = jwt.sign(userData, config.jwtSecretKey, { expiresIn: config.expiresIn });

    // 7. 登录成功响应
    return res.send({
      status: 200,
      message: '登录成功',
      token: token,
      userId: userData.id,
      student_id: userData.student_id,
      avatar: userData.avatar
    });

  } catch (err) {
    // 统一捕获所有异步错误（如数据库错误）
    return res.send({
      status: 500,
      message: err.message
    });
  }
};

// 假设已引入必要依赖（bcrypt、queryDb等）
const register = async (req, res) => {
  try {
    // 1. 校验规则（新增 nickname 相关校验）
    const student_idRegex = /^\d{12}$/; // 学号：12位数字
    const passwordRegex = /^[a-zA-Z0-9]{8,12}$/; // 密码：8-12位数字/字母
    const user = req.body;

    // 2. 基础参数校验（新增 nickname 非空检查）
    if (!user.student_id || !user.password || !user.nickname) {
      return res.send({ status: 400, message: '学号、密码或昵称不能为空' });
    } else if (!student_idRegex.test(user.student_id)) {
      return res.send({ status: 400, message: '学号应为12位数字' });
    } else if (!passwordRegex.test(user.password)) {
      return res.send({ status: 400, message: '密码应为8到12位数字或字母' });
    } else if (typeof user.nickname !== 'string' || user.nickname.trim() === '') {
      return res.send({ status: 400, message: '昵称不能为空' });
    }

    // 3. 检查学号是否已注册
    const sqlCheckUser = `select * from users where student_id=?`;
    const checkResult = await queryDb(sqlCheckUser, [user.student_id]);
    if (checkResult.length > 0) {
      return res.send({ status: 400, message: '该学号已注册' });
    }

    // 4. 检查昵称是否已被使用
    const sqlCheckNickname = `select * from users where nickname=?`;
    const nicknameResult = await queryDb(sqlCheckNickname, [user.nickname]);
    if (nicknameResult.length > 0) {
      return res.send({ status: 400, message: '该昵称已被使用，请更换' });
    }

    // 🌟 新增：生成随机头像URL
    const generateAvatar = () => {
      const picsumId = Math.floor(Math.random() * 1085); // picsum有效ID范围：0-1084
      const size = 200; // 固定尺寸（可根据需求改为随机，如100-300之间）
      const randomParam = Math.floor(Math.random() * 100000); // 防缓存随机数
      return `https://picsum.photos/id/${picsumId}/${size}?r=${randomParam}`;
    };
    const userAvatar = generateAvatar();

    // 5. 密码加密 + 插入数据库（新增 avatar 字段）
    const hashedPassword = bcrypt.hashSync(user.password, 10);
    const sqlInsertUser = `
      insert into users (student_id, password, nickname, avatar) 
      values (?, ?, ?, ?)
    `;
    const insertResult = await queryDb(sqlInsertUser, [
      user.student_id,
      hashedPassword,
      user.nickname,
      userAvatar // 存入生成的头像URL
    ]);

    // 6. 验证插入结果
    if (insertResult.affectedRows !== 1) {
      return res.send({ status: 500, message: '注册失败，请重试' });
    }

    // 7. 注册成功响应（新增返回 avatar 字段）
    return res.send({ 
      status: 200, 
      message: '注册成功，可完善个人信息', 
      userId: insertResult.insertId,
      nickname: user.nickname,
      avatar: userAvatar // 返回头像URL给前端
    });

  } catch (err) {
    return res.send({ status: 500, message: err.message });
  }
};

// 辅助函数：处理用户-课程关联
const handleUserCourses = async (userId, courseIds, res) => {
  try {
    // 1. 先删除用户原有的所有课程关联
    const sqlDelOldCourses = `DELETE FROM user_courses WHERE user_id = ?`;
    await queryDb(sqlDelOldCourses, [userId]); // 等待删除完成（无需判断结果，删除0条也正常）

    // 2. 若有新选择的课程，批量插入新关联
    if (courseIds.length === 0) {
      // 无课程选择：直接返回成功
      return res.send({ status: 200, message: '信息提交成功（未选择课程）' });
    }

    // 2.1 先检查所有课程ID是否在courses表中存在（避免无效课程）
    const sqlCheckCourses = `SELECT id FROM courses WHERE id IN (${courseIds.map(() => '?').join(',')})`;
    const courseCheckResult = await queryDb(sqlCheckCourses, courseIds);
    if (courseCheckResult.length !== courseIds.length) {
      return res.send({ status: 400, message: '部分课程不存在，请重新选择' });
    }

    // 2.2 批量插入新的用户-课程关联
    const sqlInsertCourses = `
      INSERT INTO user_courses (user_id, course_id) 
      VALUES ${courseIds.map(() => '(?, ?)').join(',')}
    `;
    // 构造参数（userId重复拼接，与courseIds一一对应）
    const courseParams = courseIds.flatMap(courseId => [userId, courseId]);
    const insertCourseRes = await queryDb(sqlInsertCourses, courseParams);

    if (insertCourseRes.affectedRows !== courseIds.length) {
      return res.send({ status: 500, message: '部分课程添加失败，请重试' });
    }

    // 所有步骤完成：返回成功
    return res.send({ status: 200, message: '所有信息提交成功' });

  } catch (err) {
    // 统一捕获所有异步错误（删除旧课程、检查课程、插入课程失败等）
    let message = '';
    if (err.message.includes('DELETE')) {
      message = `删除旧课程关联失败：${err.message}`;
    } else if (err.message.includes('SELECT')) {
      message = `检查课程有效性失败：${err.message}`;
    } else if (err.message.includes('INSERT')) {
      message = `添加课程关联失败：${err.message}`;
    } else {
      message = `课程关联处理失败：${err.message}`;
    }
    return res.send({ status: 500, message });
  }
};
// 提交用户信息接口
const submitUserInfo = async (req, res) => {
  try {
    // 1. 参数校验规则
    const gradeRegex = /^[1-4]$/; // 年级：1-4的数字
    const user = req.body;

    // 2. 基础参数校验（同步逻辑）
    if (!user.userId) {
      return res.send({ status: 400, message: '用户ID不能为空' });
    }
    if (!user.basicInfo?.major || !user.basicInfo?.grade || !user.basicInfo?.nickname) {
      return res.send({ status: 400, message: '昵称和专业和年级不能为空' });
    }
    if (!gradeRegex.test(user.basicInfo.grade)) {
      return res.send({ status: 400, message: '年级应为1-4的数字（1=大一，4=大四）' });
    }
    if (!user.preferences?.studyTime || !user.preferences?.studyStyle || !user.preferences?.communication_frequency) {
      return res.send({ status: 400, message: '学习时间、学习方式、沟通频率不能为空' });
    }
    if (!Array.isArray(user.courseIds) || user.courseIds.length > 3) {
      return res.send({ status: 400, message: '课程选择应为数组，且最多选3门' });
    }

    // 3. 检查用户是否存在
    const sqlCheckUser = `SELECT id FROM users WHERE id = ?`;
    const userResult = await queryDb(sqlCheckUser, [user.userId]);
    if (userResult.length === 0) {
      return res.send({ status: 404, message: '该用户不存在' });
    }

    // 4. 更新用户基本资料（users表）
    const sqlUpdateBasic = `
      UPDATE users 
      SET major = ?, grade = ?, intro = ? , nickname = ?
      WHERE id = ?
    `;
    const basicParams = [
      user.basicInfo.major,
      user.basicInfo.grade,
      user.basicInfo.intro || '', // 个人简介可选，默认空字符串
      user.basicInfo.nickname,
      user.userId
    ];
    const basicResult = await queryDb(sqlUpdateBasic, basicParams);
    if (basicResult.affectedRows !== 1) {
      return res.send({ status: 500, message: '基本资料更新无效果，请重试' });
    }

    // 5. 处理学习偏好（preferences表：存在则更新，不存在则新增）
    const sqlCheckPref = `SELECT id FROM preferences WHERE user_id = ?`;
    const prefResult = await queryDb(sqlCheckPref, [user.userId]);

    if (prefResult.length > 0) {
      // 5.1 偏好已存在：执行更新
      const sqlUpdatePref = `
        UPDATE preferences 
        SET study_time = ?, study_style = ?, communication_frequency = ? 
        WHERE user_id = ?
      `;
      const prefUpdateParams = [
        user.preferences.studyTime,
        user.preferences.studyStyle,
        user.preferences.communication_frequency,
        user.userId
      ];
      await queryDb(sqlUpdatePref, prefUpdateParams); // 无需额外判断，出错会被catch捕获
    } else {
      // 5.2 偏好不存在：执行新增
      const sqlInsertPref = `
        INSERT INTO preferences (user_id, study_time, study_style, communication_frequency) 
        VALUES (?, ?, ?, ?)
      `;
      const prefInsertParams = [
        user.userId,
        user.preferences.studyTime,
        user.preferences.studyStyle,
        user.preferences.communication_frequency
      ];
      const insertRes = await queryDb(sqlInsertPref, prefInsertParams);
      if (insertRes.affectedRows !== 1) {
        return res.send({ status: 500, message: '学习偏好新增无效果，请重试' });
      }
    }

    // 6. 处理用户课程（保持原函数调用逻辑）
    handleUserCourses(user.userId, user.courseIds, res);

  } catch (err) {
    // 统一捕获所有异步错误（数据库操作失败等）
    const message = err.message.includes('检查用户失败') 
      ? err.message 
      : `提交用户信息失败：${err.message}`;
    return res.send({ status: 500, message });
  }
};

// 后台接口：获取所有不重复的课程类型
const getCourseTypes = async (req, res) => {
  try {
    // SQL 语句：查询 courses 表中所有非空、不重复的 type 字段，按 type 排序
    const sql = `SELECT DISTINCT \`type\` FROM courses WHERE \`type\` IS NOT NULL ORDER BY \`type\``;
    
    // 异步查询数据库（await 等待结果）
    const result = await queryDb(sql, []); // 无参数，传空数组
    
    // 格式化返回结果：从 [{type: '数学类'}, ...] 提取为 ['数学类', ...]
    const types = result.map(item => item.type);
    
    // 成功响应（保持原格式：status=200 + data 字段）
    return res.send({
      status: 200,
      data: types
    });

  } catch (err) {
    // 统一捕获数据库错误，保留原错误提示上下文
    return res.send({
      status: 500,
      message: `获取课程类型失败：${err.message}`
    });
  }
};
// 后台接口：按课程类型获取课程（支持多选类型）
const getCoursesByType = async (req, res) => {
  try {
    // 1. 获取并校验前端传入的课程类型数组
    const { types } = req.query; 
    // 校验：必须传入非空数组（与原逻辑一致）
    if (!types || !Array.isArray(types)) {
      return res.send({ status: 400, message: '请选择课程类型' });
    }

    // 2. 拼接 SQL 语句（使用占位符避免 SQL 注入，与原逻辑一致）
    const sql = `SELECT id, name, \`type\` FROM courses WHERE \`type\` IN (${types.map(() => '?').join(',')})`;
    
    // 3. 异步查询数据库（await 等待结果）
    const result = await queryDb(sql, types); // 参数为前端传入的 types 数组

    // 4. 成功响应：返回课程列表（含 id、name、type，与原格式一致）
    return res.send({
      status: 200,
      data: result
    });

  } catch (err) {
    // 5. 统一捕获数据库错误（如 SQL 语法错误、表不存在等）
    return res.send({
      status: 500,
      message: `获取课程失败：${err.message}`
    });
  }
};
// 获取用户完整信息（个人资料+学习偏好+已选课程）
const getUserCompleteInfo = async (req, res) => {
  try {
    // 1. 获取请求参数（支持 query 传参，可根据前端需求改为 req.body）
    const { userId, student_id } = req.query;

    // 2. 参数校验：必须提供 userId 或 student_id 中的一个
    if (!userId && !student_id) {
      return res.send({
        status: 400,
        message: '用户ID（userId）或学号（student_id）不能为空'
      });
    }

    // 3. 根据参数类型构建 SQL 和查询参数（与原逻辑一致）
    let sql, params;
    if (userId) {
      // 按用户ID精确查询
      sql = 'SELECT * FROM user_complete_profile WHERE user_id = ?';
      params = [userId];
    } else {
      // 按学号精确查询（前端常用场景）
      sql = 'SELECT * FROM user_complete_profile WHERE student_id = ?';
      params = [student_id];
    }

    // 4. 异步查询数据库（await 等待结果，依赖之前的 queryDb 辅助函数）
    const result = await queryDb(sql, params);

    // 5. 处理查询结果为空的情况
    if (result.length === 0) {
      return res.send({
        status: 404,
        message: "未找到该用户的完整信息"
      });
    }

    // 6. 格式化课程列表：逗号分隔字符串 → 数组（方便前端渲染）
    const userInfo = result[0]; // 单用户查询，取第一个结果
    userInfo.selected_course_names = userInfo.selected_course_names 
      ? userInfo.selected_course_names.split(',') 
      : []; // 空值默认转为空数组

    // 7. 成功响应：返回完整用户信息（含个人资料、偏好、已选课程数组）
    return res.send({
      status: 200,
      data: userInfo
    });

  } catch (err) {
    // 8. 统一捕获错误（数据库查询失败、SQL 语法错误等）
    console.error("查询用户完整信息出错: ", err.message);
    return res.send({
      status: 500,
      message: "获取用户完整信息失败"
    });
  }
};
//获得用户收藏的问题
const getCollectQuestions = async (req, res) => {
 try {
    // 1. 接收参数：必须传用户ID（查“我的收藏”），基础分页
    const {
      userId,          // 必传：当前用户ID（谁的收藏）
      page = 1,        // 默认第1页
      pageSize = 10    // 默认每页10条
    } = req.query;

    // 2. 关键参数校验：用户ID不能为空且为数字
    if (!userId || isNaN(Number(userId))) {
      return res.status(400).json({
        status: 400,
        message: "参数错误：用户ID不能为空且必须为数字"
      });
    }
    const targetUserId = Number(userId);
    // 分页参数处理：确保有效
    const currentPage = Math.max(1, Number(page));
    const pageSizeNum = Math.max(1, Math.min(20, Number(pageSize)));
    const offset = (currentPage - 1) * pageSizeNum;

    // 3. 核心SQL：关联收藏表+问题表，只查“已收藏+正常问题”
    const getCollectedSql = `
      SELECT 
        q.id,          -- 问题ID
        q.title,       -- 问题标题
        q.tags,        -- 问题标签
        q.answer_count as answerCount, -- 回答数
        q.collect_count as collectCount, -- 总收藏数
        uqc.created_at as collectedAt, -- 我收藏的时间（从收藏表取）
        q.created_at as questionCreatedAt -- 问题创建时间
      FROM user_question_collections uqc
      -- 只关联“已收藏”的正常问题（排除删除的收藏/问题）
      INNER JOIN questions q 
        ON uqc.question_id = q.id 
        AND uqc.status = 1  -- 我的收藏状态：已收藏
        AND q.status = 1    -- 问题状态：正常
      WHERE uqc.user_id = ?  -- 只查当前用户的收藏
      ORDER BY uqc.created_at DESC  -- 按“我收藏的时间”最新排序
      LIMIT ?, ?  -- 分页
    `;

    // 4. 执行查询：收藏的问题列表 + 总条数
    const collectedResult = await queryDb(getCollectedSql, [targetUserId, offset, pageSizeNum]);
    
    // 查总收藏数（用于分页）
    const getTotalSql = `
      SELECT COUNT(*) as total 
      FROM user_question_collections uqc
      INNER JOIN questions q 
        ON uqc.question_id = q.id 
        AND uqc.status = 1 
        AND q.status = 1
      WHERE uqc.user_id = ?
    `;
    const totalResult = await queryDb(getTotalSql, [targetUserId]);
    const total = totalResult[0].total;

    // 5. 简单格式化：标签转数组，时间转ISO格式
    const formattedList = collectedResult.map(item => ({
      id: item.id,
      title: item.title,
      tags: item.tags ? item.tags.split(',') : [], // 标签转数组（前端可直接渲染）
      answerCount: item.answerCount || 0,
      collectCount: item.collectCount || 0,
      collectedAt: item.collectedAt ? new Date(item.collectedAt).toISOString() : '', // 我的收藏时间
      questionCreatedAt: item.questionCreatedAt ? new Date(item.questionCreatedAt).toISOString() : ''
    }));

    // 6. 响应结果：只返回“我的收藏列表”+基础分页
    return res.status(200).json({
      status: 200,
      message: "查询我的收藏问题成功",
      data: {
        collectedQuestions: formattedList, // 我收藏的问题列表
        pagination: {
          page: currentPage,
          pageSize: pageSizeNum,
          total: total,
          totalPages: Math.ceil(total / pageSizeNum) // 总页数
        }
      }
    });

  } catch (err) {
    console.error("查询我的收藏问题异常:", err.stack);
    res.status(500).json({
      status: 500,
      message: "查询我的收藏问题失败",
      error: process.env.NODE_ENV === 'development' ? err.message : undefined
    });
  }
};
module.exports = {
  login,
  register,
  submitUserInfo,
  getCourseTypes,
  getCoursesByType,
  getUserCompleteInfo,
  getCollectQuestions
}

